PUT Statement (File I-O)
 ----------------------------------------------------------------------------


 Action

 Writes from a variable or a random-access buffer to a file.


 Syntax


  PUT #  filenumber%,  recordnumber%,  variable

 Remarks


 Do not use  PUT on ISAM files.

 The  PUT statement uses the following arguments.

-----------------------------------------------------------------------------
 Argument                                Description
 ----------------------------------------------------------------------------
  filenumber%                            The number used in the  OPEN
                                         statement to open the file.

  recordnumber%                          For random-access files, the
                                         number of the record to be written.
                                         For binary-mode files, the byte
                                         position where writing is done.
                                         The first record or byte position
                                         in a file is 1. If you omit
 Argument                                Description
 ----------------------------------------------------------------------------
                                         in a file is 1. If you omit
                                         recordnumber%, the next record or
                                         byte (the one after the last  GET
                                         or  PUT statement, or the one
                                         pointed to by the last  SEEK) is
                                         written to. The largest possible
                                         record number is 231 -1 or
                                         2,147,483,647.

  variable                               A variable that contains output to
                                         be written to the file. The  PUT
                                         statement writes as many bytes to
                                         the file as there are bytes in the
                                         variable.

                                         If you specify a variable, you do
                                         not need to use  MKI$,  MKL$,
                                         MKS$,  MKD$, or  MKC$ to convert
                                         numeric fields before writing. You
 Argument                                Description
 ----------------------------------------------------------------------------
                                         numeric fields before writing. You
                                         cannot use a  FIELD statement with
                                         the file if you use the variable
                                         argument.

                                         For random-access files, you can
                                         use any variable as long as the
                                         length of the variable is less
                                         than or equal to the length of the
                                         record. Usually, a record variable
                                         defined to match the fields in a
                                         data record is used. A record
                                         cannot be longer than 32,767 bytes.

                                         For binary-mode files, you can use
                                         any variable.

                                         When you use a variable-length
                                         string variable, the statement
 Argument                                Description
 ----------------------------------------------------------------------------
                                         string variable, the statement
                                         writes as many bytes as there are
                                         characters in the string's value.
                                         For example, the following two
                                         statements write 15 bytes to file
                                         number 1.

                                         VarString$=STRING$(15, "X")

                                         PUT #1,,VarString$

                                         See the examples for more
                                         information about using variables
                                         rather than  FIELD statements for
                                         random-access files.





 You can omit  recordnumber%,  variable, or both. If you omit  recordnumber%
 but include a variable, you must still include the commas.


 PUT #4,,FileBuffer

 If you omit both arguments, do not include the commas.


 PUT #4

  GET and  PUT statements allow fixed-length input and output for BASIC
 communication files. Be careful using  GET and  PUT for communication
 because  PUT writes a fixed number of characters and may wait indefinitely
 if there is a communication failure.




 Note


 When using a file buffer defined by a  FIELD statement,  LSET,  RSET,  PRINT
 # ,  PRINT #  USING, and  WRITE # can be used to put characters in the
 random-file buffer before executing a  PUT statement. In the case of  WRITE
 #, BASIC pads the buffer with spaces up to the carriage return. If you
 attempt to read or write past the end of the buffer, BASIC generates the
 error message FIELD overflow.



 See Also


  CVI,  CVL,  CVS,  CVD,  CVC;  GET (File I-O);  LSET;  MKI$,  MKL$,  MKS$,
 MKD$,  MKC$;  OPEN (File I-O)



 Example


 The following example reads names and test scores from the console and
 stores them in a random-access file.

 ' Define record fields.

 TYPE TestRecord

    NameField  AS STRING * 20

    ScoreField AS SINGLE

 END TYPE

 DIM FileBuffer AS TestRecord

 DIM I AS LONG

 ' Open the test data file.

 OPEN "TESTDAT.DAT" FOR RANDOM AS #1 LEN = LEN(FileBuffer)

 ' Read pairs of names and scores from the console.

 CLS    ' Clear screen.

 I = 0

 DO

     I = I + 1

     INPUT "Name ? ", FileBuffer.NameField

     INPUT "Score? ", FileBuffer.ScoreField

     INPUT "-->More (y-n)? ", Resp$

     PUT #1, I, FileBuffer

 LOOP UNTIL UCASE$(MID$(Resp$, 1, 1)) = "N"

 PRINT I; " records written."

 CLOSE #1

 KILL "TESTDAT.DAT"' Remove file from disk.